There's no good reason to release the lock only to immediately reacquire
it for exception handling.  That might allow commands to be started (or
continued) while still propagating irrelevant response errors.

By moving the `rescue` clause inside the `synchronize` block, `begin`
and `end` are now superfluous and can be removed.  But that makes the
diff seem much larger than it should, so I'm saving it for a later
branch.

Although it wasn't obvious at first glance, because nearly every
possible error is caught by a `rescue Exception` clause, this is
effectively no different from what was already happening.  This
structure makes that much more obvious.

Also, by moving this code into the `ensure`, it allows us to simplify
error handling elsewhere, by simply raising or re-raising an exception.

This also lets us move `state_logout!` inside the `synchronize` block.

By resetting `@exception` inside the synchronize block at the end of the
loop, we don't need to release and immediately reacquire the lock each
time through the loop.

The receiver thread now enters the logout state _before_ signaling the
conditional variables for the last time.  This is less surprising than
doing it afterward, and it also makes some of the other `state_logout!`
calls redundant.

With this change, an EOFError `@exception` may be assigned a receiver
thread backtrace.  Previously, it might've been raised in the client
thread which, would set the backtrace for that client thread.

Since we're handling everything inside the ensure clause, we can drop
the rescue clause and use `$!` in the ensure clause.

But please note that this seems to trigger a TruffleRuby bug:
truffleruby/truffleruby#4308